Tech Arsenal 1/Tech Arsenal (Arsenal Computer).ISO/tek-01/cppmatrx.zip/MATRIX.C

C/C++ Source or Header | 1991-02-02 | 8.4 KB | 381 lines

#include <stdlib.h>
#include <iostream.h>
#include <stdarg.h>
#include <math.h>

#include "matrix.h"
#include "matparse.h"

matrix::matrix (size_t matrix_length, ...)
{
   if (matrix_length == 0)
      matrix_error ("Cannot create a matrix of size 0.");

   va_list argptr;
   size_t elem_count;

   matrix_size = matrix_length;
   matrix_data = new matrix_t [matrix_size*matrix_size];

   matrix_t *i;
   size_t count;

   va_start (argptr, matrix_length);

   elem_count = matrix_size*matrix_size;

   for (i = matrix_data, count = 1; count <= elem_count; i++, count++)  {
         *i = (matrix_t) (va_arg (argptr, matrix_t));
      }

   va_end (argptr);
}

matrix::matrix (char *dummy, size_t matrix_length,matrix_t fill_value)
{
   if (matrix_length == 0)
      matrix_error ("Cannot create a matrix of size 0.");

   size_t elem_count;

   matrix_size = matrix_length;
   matrix_data = new matrix_t [matrix_size*matrix_size];

   matrix_t *i;
   size_t count;

   elem_count = matrix_size*matrix_size;

   for (i = matrix_data, count = 1; count <= elem_count; count++, i++)
      *i = (matrix_t) fill_value;
}

void matrix::print_matrix (void)
{
   matrix_t *i;
   size_t row_count, column_count;

   cout << '\n';

   for (i = matrix_data, row_count = 0, column_count = 0; row_count < matrix_size; i++)   {
         cout << *i << ' ';
         if (column_count == (matrix_size - 1)) {
               column_count = 0;
               row_count++;
               cout << '\n';
            }
               else
                  column_count++;
      }
}

matrix::matrix (matrix &m)
{
   matrix_t *i, *j;
   size_t count, elem_count;

   matrix_size = m.matrix_size;
   elem_count = matrix_size*matrix_size;

   matrix_data = new matrix_t [elem_count];

   for (i = matrix_data, j = m.matrix_data, count = 1; count <= elem_count; count++, i++, j++)
      *i = *j;
}

matrix matrix::operator= (matrix &m)
{

   size_t elem_count;
   matrix_t *i, *j;

   size_t count;

   delete matrix_data;  // erase the current contents of the matrix on the left
                        // side of the assignment

   matrix_size = m.matrix_size;
   elem_count = matrix_size * matrix_size;

   matrix_data = new matrix_t [elem_count];  // allocate space for the new matrix, identical to the argument

   for (i = matrix_data, j = m.matrix_data, count = 1; count <= elem_count; count++, i++, j++)
      *i = *j;

   return *this;
}

matrix matrix::operator+ (matrix m)
{
   if (matrix_size != m.matrix_size)
      matrix_error ("Cannot add matrices of different sizes.");

   matrix temp ("*",matrix_size);
   matrix_t *i, *j, *k;
   size_t counter;
   size_t elem_count;

   elem_count = matrix_size * matrix_size;

   for (i = matrix_data, j = m.matrix_data, k = temp.matrix_data, counter = 1;
        counter <= elem_count; i++, j++, k++, counter++)
           *k = *i + *j;

   return temp;
}

matrix matrix::operator- (matrix m)
{
   if (matrix_size != m.matrix_size)
      matrix_error ("Cannot subtract matrices of different sizes.");

   matrix temp ("*",matrix_size);
   matrix_t *i, *j, *k;
   size_t counter;
   size_t elem_count;

   elem_count = matrix_size * matrix_size;

   for (i = matrix_data, j = m.matrix_data, k = temp.matrix_data, counter = 1;
        counter <= elem_count; i++, j++, k++, counter++)
           *k = *i - *j;

   return temp;
}


inline void swap (matrix_t &a, matrix_t &b)
{
   matrix_t temp;

   temp = a;
   a = b;
   b = temp;
}


void transpose (matrix &m)
{
   size_t i,j;

   for (i = 2; i <= m.matrix_size; i++)
      for (j = 1; j <= i-1; j++)
         swap (m (i,j), m (j,i));
}


matrix minor (matrix m, size_t m_row, size_t m_column)
{
   if (m_row == 0 || m_column == 0)
      matrix_error ("Invalid matrix indices passed to function minor.");

   matrix temp ("*", m.matrix_size-1);
   size_t column, row;
   size_t temp_column, temp_row;

   for (column = 1, temp_column = 1; column <= m.matrix_size; column++)  {
         if (column != m_column) {
               for (row = 1, temp_row = 1; row <= m.matrix_size; row++)
                  if (row != m_row) {
                     temp (temp_row, temp_column) = m (row, column);
                     temp_row++;
                  }

               temp_column++;
            }
      }

   return temp;
}


matrix_t det (matrix m)
{
   if (m.matrix_size == 1)
      matrix_error ("Cannot evaluate the determinate of a matrix of size 1.");

   if (m.matrix_size == 2)
      return m (1,1)*m (2,2) - m (1,2)*m (2,1);
         else  {
                 size_t i;
                 matrix_t value = 0;

                 for (i = 1; i <= m.matrix_size; i++)
                    value += m (1,i) * cofactor (m, 1, i);

                 return value;
            }
}



int matrix::operator== (matrix m)
{

   if (matrix_size == m.matrix_size)
      return ! memcmp (matrix_data, m.matrix_data, matrix_size*matrix_size);
         else
            return 0;
}


int matrix::operator!= (matrix m)
{

   if (matrix_size == m.matrix_size)
      return memcmp (matrix_data, m.matrix_data, matrix_size*matrix_size);
         else
            return 1;
}

matrix operator* (matrix m, double r)
{
   matrix temp ("*",m.matrix_size);
   matrix_t *i, *t;
   size_t count, elem_count = m.matrix_size*m.matrix_size;

   for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
      *t = *i * r;

   return temp;
}

matrix operator* (double r, matrix m)
{
   matrix temp ("*",m.matrix_size);
   matrix_t *i, *t;
   size_t count, elem_count = m.matrix_size*m.matrix_size;

   for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
      *t = *i * r;

   return temp;
}

matrix operator* (matrix m, int r)
{
   matrix temp ("*",m.matrix_size);
   matrix_t *i, *t;
   size_t count, elem_count = m.matrix_size*m.matrix_size;

   for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
      *t = *i * r;

   return temp;
}

matrix operator* (int r, matrix m)
{
   matrix temp ("*",m.matrix_size);
   matrix_t *i, *t;
   size_t count, elem_count = m.matrix_size*m.matrix_size;

   for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
      *t = *i * r;

   return temp;
}

matrix_t cofactor (matrix m, size_t m_row, size_t m_column)
{
   if (m_row == 0 || m_column == 0)
      matrix_error ("Invalid matrix indices passed to function cofactor.");

   int factor;

   if ((m_row+m_column) % 2)
      factor = (-1);
         else
            factor = 1;

   return (matrix_t) factor * det (minor (m, m_row, m_column));
}


matrix matrix::operator- (void)
{
   matrix temp ("*",matrix_size);
   matrix_t *i, *t;
   size_t count, elem_count = matrix_size*matrix_size;

   for (i = matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
      *t = -*i;

   return temp;
}

matrix matrix::operator* (matrix m)
{
   if (matrix_size != m.matrix_size)
      matrix_error ("Cannot multiply matrices of different dimensions.");

   size_t i,j,k;
   matrix temp ("*",matrix_size);

   for (i = 1; i <= matrix_size; i++)  {

         for (j = 1; j <= matrix_size; j++)  {
               matrix_t value = 0;

               for (k = 1; k <= matrix_size; k++)
                  value += get_elem (j,k)*m (k,i);

               temp (j,i) = value;
            }
      }

   return temp;
}


ostream& operator<< (ostream &s, matrix m)
{
   size_t i,j;

   s << '\n';

   for (i = 1; i <= m.matrix_size; i++)   {
         for (j = 1; j <= m.matrix_size; j++)
            s << m (i,j) << ' ';

         s << '\n';
      }

   return s;
}

istream& operator>> (istream &s, matrix &m)
{
   size_t i,j;

   delete m.matrix_data;
   s >> m.matrix_size;
   m.matrix_data = new matrix_t [m.matrix_size*m.matrix_size];

   for (i = 1; i <= m.matrix_size; i++)
      for (j = 1; j <= m.matrix_size; j++)
            s >> m (i,j);

   return s;
}

void matrix_error (char *message)
{
   cerr << "\nMatrix error: " << message << '\n';
   exit (1);
}


main (void)
{
   cout << "\nTesting matrix calculator.\n";
   cout << "\nPlease enter a matrix expression:\n";
   cout << expression ();

   return 0;
}